package com.blog.cmrpersonalblog.controller;

import cn.dev33.satoken.annotation.SaCheckLogin;
import cn.dev33.satoken.stp.StpUtil;
import com.blog.cmrpersonalblog.common.Result;
import com.blog.cmrpersonalblog.dto.file.respnose.FileUploadResponse;
import com.blog.cmrpersonalblog.dto.user.request.UserProfileUpdateRequest;
import com.blog.cmrpersonalblog.enums.FileUploadType;
import com.blog.cmrpersonalblog.service.UnifiedFileUploadService;
import com.blog.cmrpersonalblog.service.UserProfileService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

/**
 * 文件上传控制器
 */
@Slf4j
@RestController
@RequestMapping("/api/upload")
@CrossOrigin(origins = "*", maxAge = 3600)
@SaCheckLogin
public class FileUploadController {

   @Resource
    private UnifiedFileUploadService unifiedFileUploadService;
    
   @Resource
    private UserProfileService userProfileService;


    // ==================== 新的统一文件上传接口 ====================

    /**
     * 统一文件上传接口
     * 
     * @param file 要上传的文件
     * @param type 上传类型（avatar, article_cover, comment_image, general_image）
     * @return 上传结果
     */
    @PostMapping("/unified")
    public Result<FileUploadResponse> unifiedUpload(
            @RequestParam("file") MultipartFile file,
            @RequestParam("type") String type) {
        
        Long currentUserId = StpUtil.getLoginIdAsLong();
        log.info("统一文件上传: userId={}, type={}, fileName={}, fileSize={}", 
            currentUserId, type, file.getOriginalFilename(), file.getSize());
        
        try {
            // 验证文件
            if (file.isEmpty()) {
                return Result.error("请选择要上传的文件");
            }
            
            // 上传文件
            FileUploadResponse response = unifiedFileUploadService.uploadFile(file, type, currentUserId);
            
            // 如果是头像上传，需要更新数据库
            if ("avatar".equals(type)) {
                UserProfileUpdateRequest updateRequest = new UserProfileUpdateRequest();
                updateRequest.setAvatar(response.getFileUrl());
                
                boolean updateSuccess = userProfileService.updateUserProfile(currentUserId, updateRequest);
                if (!updateSuccess) {
                    // 如果更新失败，删除已上传的文件
                    unifiedFileUploadService.deleteFile(response.getRelativePath(), type);
                    return Result.error("更新用户头像失败");
                }
                log.info("统一文件上传并更新用户头像成功: userId={}, avatarUrl={}", currentUserId, response.getFileUrl());
            }
            
            log.info("统一文件上传成功: type={}, fileUrl={}", type, response.getFileUrl());
            return Result.success("文件上传成功", response);
            
        } catch (Exception e) {
            log.error("统一文件上传失败: type={}, fileName={}, error={}", type, file.getOriginalFilename(), e.getMessage(), e);
            return Result.error("文件上传失败：" + e.getMessage());
        }
    }

    /**
     * 上传文章封面
     * 
     * @param file 要上传的文件
     * @return 上传结果
     */
    @PostMapping("/article-cover")
    public Result<FileUploadResponse> uploadArticleCover(@RequestParam("file") MultipartFile file) {
        Long currentUserId = StpUtil.getLoginIdAsLong();
        log.info("用户上传文章封面: userId={}, fileName={}, fileSize={}", 
            currentUserId, file.getOriginalFilename(), file.getSize());
        
        try {
            // 验证文件
            if (file.isEmpty()) {
                return Result.error("请选择要上传的文件");
            }
            
            // 上传文件
            FileUploadResponse response = unifiedFileUploadService.uploadFile(file, FileUploadType.ARTICLE_COVER, currentUserId);
            
            log.info("文章封面上传成功: {}", response.getFileUrl());
            return Result.success("文章封面上传成功", response);
            
        } catch (Exception e) {
            log.error("文章封面上传失败: fileName={}, error={}", file.getOriginalFilename(), e.getMessage(), e);
            return Result.error("文章封面上传失败：" + e.getMessage());
        }
    }

    /**
     * ❌ 已废弃：请使用 POST /api/user-comment/upload-image 评论图片上传接口
     * 该接口包含评论图片的完整业务逻辑（临时存储、令牌验证等）
     */
    @Deprecated
    @PostMapping("/comment-image")
    public Result<String> uploadCommentImage(@RequestParam("file") MultipartFile file) {
        return Result.error("此接口已废弃，请使用 POST /api/user-comment/upload-image 评论图片上传接口");
    }

    /**
     * 上传用户头像（新版本，使用统一上传系统）
     * 
     * @param file 要上传的文件
     * @return 上传结果
     */
    @PostMapping("/avatar")
    public Result<FileUploadResponse> uploadAvatarNew(@RequestParam("file") MultipartFile file) {
        Long currentUserId = StpUtil.getLoginIdAsLong();
        log.info("用户上传头像(新版): userId={}, fileName={}, fileSize={}", 
            currentUserId, file.getOriginalFilename(), file.getSize());
        
        try {
            // 验证文件
            if (file.isEmpty()) {
                return Result.error("请选择要上传的文件");
            }
            
            // 上传文件
            FileUploadResponse response = unifiedFileUploadService.uploadFile(file, FileUploadType.AVATAR, currentUserId);
            
            // 更新用户头像URL到数据库
            UserProfileUpdateRequest updateRequest = new UserProfileUpdateRequest();
            updateRequest.setAvatar(response.getFileUrl());
            
            boolean updateSuccess = userProfileService.updateUserProfile(currentUserId, updateRequest);
            if (!updateSuccess) {
                // 如果更新失败，删除已上传的文件
                unifiedFileUploadService.deleteFile(response.getRelativePath(), FileUploadType.AVATAR);
                return Result.error("更新用户头像失败");
            }
            
            log.info("用户头像上传并更新成功: userId={}, avatarUrl={}", currentUserId, response.getFileUrl());
            return Result.success("头像上传成功", response);
            
        } catch (Exception e) {
            log.error("头像上传失败(新版): fileName={}, error={}", file.getOriginalFilename(), e.getMessage(), e);
            return Result.error("头像上传失败：" + e.getMessage());
        }
    }

    /**
     * 上传通用图片
     * 
     * @param file 要上传的文件
     * @return 上传结果
     */
    @PostMapping("/general-image")
    public Result<FileUploadResponse> uploadGeneralImage(@RequestParam("file") MultipartFile file) {
        Long currentUserId = StpUtil.getLoginIdAsLong();
        log.info("用户上传通用图片: userId={}, fileName={}, fileSize={}", 
            currentUserId, file.getOriginalFilename(), file.getSize());
        
        try {
            // 验证文件
            if (file.isEmpty()) {
                return Result.error("请选择要上传的文件");
            }
            
            // 上传文件
            FileUploadResponse response = unifiedFileUploadService.uploadFile(file, FileUploadType.GENERAL_IMAGE, currentUserId);
            
            log.info("通用图片上传成功: {}", response.getFileUrl());
            return Result.success("通用图片上传成功", response);
            
        } catch (Exception e) {
            log.error("通用图片上传失败: fileName={}, error={}", file.getOriginalFilename(), e.getMessage(), e);
            return Result.error("通用图片上传失败：" + e.getMessage());
        }
    }

    /**
     * 删除文件
     * 
     * @param relativePath 文件相对路径
     * @param type 文件类型
     * @return 删除结果
     */
    @DeleteMapping("/file")
    public Result<String> deleteFile(
            @RequestParam("path") String relativePath,
            @RequestParam("type") String type) {
        
        Long currentUserId = StpUtil.getLoginIdAsLong();
        log.info("用户删除文件: userId={}, type={}, path={}", currentUserId, type, relativePath);
        
        try {
            boolean success = unifiedFileUploadService.deleteFile(relativePath, type);
            
            if (success) {
                return Result.success("文件删除成功");
            } else {
                return Result.error("文件删除失败");
            }
            
        } catch (Exception e) {
            log.error("文件删除失败: type={}, path={}, error={}", type, relativePath, e.getMessage(), e);
            return Result.error("文件删除失败：" + e.getMessage());
        }
    }

    /**
     * 验证文件
     * 
     * @param file 要验证的文件
     * @param type 文件类型
     * @return 验证结果
     */
    @PostMapping("/validate")
    public Result<Boolean> validateFile(
            @RequestParam("file") MultipartFile file,
            @RequestParam("type") String type) {
        
        try {
            boolean isValid = unifiedFileUploadService.validateFile(file, type);
            return Result.success("文件验证完成", isValid);
            
        } catch (Exception e) {
            log.error("文件验证失败: type={}, fileName={}, error={}", type, file.getOriginalFilename(), e.getMessage(), e);
            return Result.error("文件验证失败：" + e.getMessage());
        }
    }
}
